home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / program / 316 / libsrc / flonum.s < prev    next >
Encoding:
Text File  |  1988-10-20  |  15.3 KB  |  804 lines
  1. #
  2. #
  3. #    Floating point support code.  What a crock!
  4. #
  5. #    A float looks like:
  6. #
  7. #    |S|E.x.p ... |M.a.n.t.i.s.s.a ... |
  8. #    +-+----------+--------------------+
  9. #
  10. #    where s is the sign bit, Exp is 8 bits of exponent, interpreted
  11. #    as E + 126, and Mantissa is 23 bits of fraction, with a
  12. #    hidden bit.  The point is to the left of the hidden bit.
  13. #    Doubles have another word of mantissa following.
  14. #
  15. #    All these routines have calling sequences like c routines,
  16. #    ie args on stack in backwards order, return values in d0
  17. #
  18.  
  19. # union double_di { double d; int i[2]; };
  20. # union flt_or_int { int i; float f; };
  21.  
  22. # #ifdef L_divdf3
  23. # double
  24. # _divdf3 (a, b)
  25. #      double a, b;
  26. # {
  27. #   return a / b;
  28. # }
  29. # #endif
  30. .text
  31.     .even
  32. .globl __divdf3
  33. __divdf3:
  34.     movel    sp@(12),sp@-
  35.     movel    sp@(8),sp@-
  36.     jsr    __divsf3
  37.     addql    #8,sp
  38.     clrl    d1        | kludge!!!
  39.     rts            | sigh
  40. # 
  41. # #ifdef L_muldf3
  42. # double
  43. # _muldf3 (a, b)
  44. #      double a, b;
  45. # {
  46. #   return a * b;
  47. # }
  48. # #endif
  49.  
  50. .text
  51.     .even
  52. .globl __muldf3
  53. __muldf3:
  54.     movel    sp@(12),sp@-
  55.     movel    sp@(8),sp@-
  56.     jsr    __mulsf3
  57.     addql    #8,sp
  58.     clrl    d1        | kludge!!!
  59.     rts            | sigh
  60. # 
  61. # #ifdef L_negdf2
  62. # double
  63. # _negdf2 (a)
  64. #      double a;
  65. # {
  66. #   return -a;
  67. # }
  68. # #endif
  69.  
  70. .text
  71.     .even
  72. .globl __negdf2
  73. __negdf2:
  74.     movel    sp@(8),d1        | get a lo
  75.     movel    sp@(4),d0        | get a hi
  76.     beq    negdf2_z        | zero, leave it
  77.     eorl    #0x80000000,d0        | twiddle sign
  78. negdf2_z:
  79.     rts
  80. # 
  81. # #ifdef L_adddf3
  82. # double
  83. # _adddf3 (a, b)
  84. #      double a, b;
  85. # {
  86. #   return a + b;
  87. # }
  88. # #endif
  89.  
  90. .text
  91.     .even
  92. .globl __adddf3
  93. __adddf3:
  94.     movel    sp@(12),sp@-
  95.     movel    sp@(8),sp@-
  96.     jsr    __addsf3
  97.     addql    #8,sp
  98.     clrl    d1        | kludge!!!
  99.     rts            | sigh
  100. # 
  101. # #ifdef L_subdf3
  102. # double
  103. # _subdf3 (a, b)
  104. #      double a, b;
  105. # {
  106. #   return a - b;
  107. # }
  108. # #endif
  109.  
  110. .text
  111.     .even
  112. .globl __subdf3
  113. __subdf3:
  114.     movel    sp@(12),sp@-
  115.     movel    sp@(8),sp@-
  116.     jsr    __subsf3
  117.     addql    #8,sp
  118.     clrl    d1        | kludge!!!
  119.     rts            | sigh
  120. # 
  121. # #ifdef L_cmpdf2
  122. # int
  123. # _cmpdf2 (a, b)
  124. #      double a, b;
  125. # {
  126. #   if (a > b)
  127. #     return 1;
  128. #   else if (a < b)
  129. #     return -1;
  130. #   return 0;
  131. # }
  132. # #endif
  133.  
  134. .text
  135.     .even
  136. .globl __cmpdf2
  137. __cmpdf2:
  138.     movel    sp@(4),d0    | get b hi
  139.     movel    sp@(12),d1    | get a hi
  140. |
  141. | crockery.  If both neg and not equal, this algorithm lose.  find a better one!
  142. |
  143.     bpl    cmpdf2_p
  144.     tstl    d0
  145.     bpl    cmpdf2_p
  146.     cmpl    d1,d0
  147.     bgt    cmpdf2_m
  148.     blt    cmpdf2_1
  149.     beq    cmpdf2_z
  150. cmpdf2_p:
  151.     cmpl    d1,d0        | get a hi
  152.     beq    cmpdf2_z    | if eq, return 0
  153.     bgt    cmpdf2_1    | if greater, return 1
  154. cmpdf2_m:
  155.     movel    #-1,d0        | else return -1
  156.     rts
  157. cmpdf2_z:
  158.     clrl    d0
  159.     rts
  160. cmpdf2_1:
  161.     movel    #1,d0
  162.     rts            | sigh
  163. # 
  164. # #ifdef L_fixunsdfsi
  165. # _fixunsdfsi (a)
  166. #      double a;
  167. # {
  168. #   return (unsigned int) a;
  169. # }
  170. # #endif
  171.  
  172. .text
  173.     .even
  174. .globl __fixunsdfsi
  175. __fixunsdfsi:
  176.     clrl d0
  177.     clrl d1
  178.     rts            | sigh
  179. # 
  180. # #ifdef L_fixunsdfdi
  181. # double
  182. # _fixunsdfdi (a)
  183. #      double a;
  184. # {
  185. #   union double_di u;
  186. #   u.i[LOW] = (unsigned int) a;
  187. #   u.i[HIGH] = 0;
  188. #   return u.d;
  189. # }
  190. # #endif
  191.  
  192. .text
  193.     .even
  194. .globl __fixunsdfdi
  195. __fixunsdfdi:
  196.     clrl d0
  197.     clrl d1
  198.     rts            | sigh
  199. # 
  200. # #ifdef L_fixdfsi
  201. # _fixdfsi (a)
  202. #      double a;
  203. # {
  204. #   return (int) a;
  205. # }
  206. # #endif
  207.  
  208. .text
  209.     .even
  210. .globl __fixdfsi
  211. __fixdfsi:
  212.     link    a6,#0
  213.     movel    d2,sp@-        | save reg
  214.     clrl    d2        | sign flag
  215.     movel    a6@(8),d0    | get the float
  216.     beq    fixdfsi_ret
  217.     bpl    fixdfsi_1
  218.     addql    #1,d2
  219. fixdfsi_1:
  220.     movel    d0,d1        | snag the exp
  221.     lsrl    #7,d1
  222.     lsrl    #8,d1
  223.     lsrl    #8,d1
  224.     andl    #0xFF,d1
  225.     subl    #126,d1
  226.     andl    #0x7FFFFF,d0    | zap cruft
  227.     orl    #0x800000,d0    | put back hidden bit
  228. |
  229. | at this point the mantissa looks like 2^24 * integer value.
  230. | if Exp is 24, we're done.  If it's less, we shift right,
  231. | else left
  232. |
  233. fixdfsi_2:
  234.     cmpl    #24,d1
  235.     beq    fixdfsi_4    | we're done
  236.     bmi    fixdfsi_3    | less, shift right
  237.     lsll    #1,d0        | greater, shift it left one
  238.     subql    #1,d1        | and dec exp
  239.     bra    fixdfsi_2
  240. fixdfsi_3:
  241.     lsrl    #1,d0        | shift right one
  242.     addql    #1,d1        | and inc exp
  243.     bra    fixdfsi_2
  244. fixdfsi_4:
  245.     tstl    d2        | negative?
  246.     beq    fixdfsi_ret
  247.     negl    d0
  248. fixdfsi_ret:
  249.     movel    sp@+,d2        | get d2 back
  250.     unlk    a6
  251.     rts
  252. # 
  253. # #ifdef L_fixdfdi
  254. # double
  255. # _fixdfdi (a)
  256. #      double a;
  257. # {
  258. #   union double_di u;
  259. #   u.i[LOW] = (int) a;
  260. #   u.i[HIGH] = (int) a < 0 ? -1 : 0;
  261. #   return u.d;
  262. # }
  263. # #endif
  264.  
  265. .text
  266.     .even
  267. .globl __fixdfdi
  268. __fixdfdi:
  269.     clrl d0
  270.     clrl d1
  271.     rts            | sigh
  272. # 
  273. # #ifdef L_floatsidf
  274. # double
  275. # _floatsidf (a)
  276. #      int a;
  277. # {
  278. #   return (double) a;
  279. # }
  280. # #endif
  281.  
  282. .text
  283.     .even
  284. .globl __floatsidf
  285. __floatsidf:
  286.     link    a6,#0        | set up frame
  287.     movel    d2,sp@-        | save d2; sign flag
  288.     clrl    d2        | not negative yet
  289.     movel    #24,d1        | exponent so far
  290.     movel    a6@(8),d0    | get the int
  291.     beq    floatsidf_ret    | zero?
  292.     bpl    floatsidf_1    | pos, it's ok
  293.     negl    d0        | negate it
  294.     addql    #1,d2        | bump sign
  295. floatsidf_1:
  296. |
  297. | normalize right if necessary
  298. |
  299.     cmpl    #0xFFFFFF,d0    | too big?
  300.     ble    floatsidf_2    | nope, see if need to slide left
  301.     addql    #1,d1        | bump exp
  302.     lsrl    #1,d0        | and slide mantissa right one
  303.     bra    floatsidf_1
  304. floatsidf_2:
  305.     btst    #23,d0        | got a bit up here yet?
  306.     bne    floatsidf_3    | nope, go left
  307.     subql    #1,d1        | dec exp
  308.     lsll    #1,d0        | and slide mantissa left one
  309.     bra    floatsidf_2
  310. floatsidf_3:
  311. |
  312. | now put it all together
  313. |
  314.     andl    #0x7FFFFF,d0    | zap hidden bit
  315.     addl    #126,d1        | offset exp
  316.     andl    #0xFF,d1    | trim it
  317.     lsll    #8,d1        | shift up
  318.     lsll    #8,d1
  319.     lsll    #7,d1
  320.     orl    d1,d0        | stuff it in
  321.     tstl    d2        | negative?
  322.     beq    floatsidf_ret
  323.     orl    #0x80000000,d0
  324. floatsidf_ret:
  325.     movel    sp@+,d2
  326.     clrl    d1        | ???
  327.     unlk    a6
  328.     rts            | sigh
  329. # 
  330. # #ifdef L_floatdidf
  331. # double
  332. # _floatdidf (u)
  333. #      union double_di u;
  334. # {
  335. #   register double hi
  336. #     = ((double) u.i[HIGH]) * (double) 0x10000 * (double) 0x10000;
  337. #   register double low = (unsigned int) u.i[LOW];
  338. #   return hi + low;
  339. # }
  340. # #endif
  341.  
  342. .text
  343.     .even
  344. .globl __floatdidf
  345. __floatdidf:
  346.     clrl d0
  347.     clrl d1
  348.     rts            | sigh
  349. # 
  350. # #define INTIFY(FLOATVAL)  (intify.f = (FLOATVAL), intify.i)
  351. # 
  352. # #ifdef L_addsf3
  353. # int
  354. # _addsf3 (a, b)
  355. #      union flt_or_int a, b;
  356. # {
  357. #   union flt_or_int intify;
  358. #   return INTIFY (a.f + b.f);
  359. # }
  360. # #endif
  361.  
  362. .text
  363.     .even
  364. .globl __addsf3
  365. __addsf3:
  366.     link    a6,#0        | don't need any locals
  367.     moveml    #0x3F00,sp@-    | save all data registers
  368.     movel    a6@(8),d0    | get a
  369.     beq    addsf_ret_b    |  zero .. just return b
  370.     movel    #23,d6        | shift count
  371.     movel    d0,d2        | get the exponent
  372.     lsrl    d6,d2        | and shift right
  373.     andl    #0xFF,d2    | no sign bit
  374.     subl    #126,d2        | offset the exponent
  375.     movel    a6@(12),d1    | get b
  376.     beq    addsf_ret_a
  377.     movel    d1,d3        | get the exponent for b
  378.     lsrl    d6,d3        | and shift right, with implicit extend
  379.     andl    #0xFF,d3    | make sure we didn't get a sign bit
  380.     subl    #126,d3        | off set this one too
  381.  
  382.     andl    #0x7FFFFF,d0    | mask a for mantissa
  383.     orl    #0x800000,d0    | and put in hidden bit
  384.     tstl    a6@(8)        | test the original value
  385.     bpl    addsf_1        | pos, ok
  386.     negl    d0        | neg, negate the mantissa
  387. addsf_1:
  388.     andl    #0x7FFFFF,d1    | mask b for mantissa
  389.     orl    #0x800000,d1    | ditto
  390.     tstl    a6@(12)        | test ...
  391.     bpl    addsf_2
  392.     negl    d1        | negate this one
  393. addsf_2:
  394.     cmpl    d2,d3        | compare Ea to Eb
  395.     blt    addsf_3        | Ea > Eb
  396.  
  397.     movel    d3,d5        | get Eb
  398.     subl    d2,d5        | subtract Ea
  399.     asrl    d5,d0        |  yielding count to shift Ma right
  400.     movel    d3,d5        | use this as resultant exponent
  401.     bra    addsf_4        | and go rejoin common part
  402. addsf_3:
  403.     movel    d2,d5        | get Ea
  404.     subl    d3,d5        | subtract Eb
  405.     asrl    d5,d1        |  yielding count to shift Mb right
  406.     movel    d2,d5        | use this as resultant exponent
  407.  
  408. addsf_4:
  409.     clrl    d7        | zap sign flag
  410.     addl    d1,d0        | add Mb to Ma
  411.  
  412.  
  413.     beq    addsf_z        | zero? ok, go return zero
  414.     bpl    addsf_5        | positive? ok, go scale it
  415.     negl    d0        | negate Mr
  416.     movel    #1,d7        | remember sign
  417. addsf_5:
  418.     btst    #24,d0        | carry?
  419.     beq    addsf_6        | nope, it's ok as is
  420.     asrl    #1,d0        | shift right one
  421.     addql    #1,d5        | inc exp
  422.  
  423. | zzz check for overflow in here someplace
  424.  
  425. addsf_6:
  426.     btst    #23,d0        | got a bit in the right place yet?
  427.     bne    addsf_7        | yes, we're done
  428.     lsll    #1,d0        | shift left one
  429.     subql    #1,d5        | dec exponent
  430.     bra    addsf_6
  431. addsf_7:
  432.     andl    #0x7FFFFF,d0    | zap out hidden bit
  433.     addl    #126,d5        | add offset to exp
  434.     andl    #0xFF,d5    | zap to 8 bits
  435.     movel    #23,d6        | shift count
  436.     lsll    d6,d5        | shift the exp up
  437.     orl    d5,d0        | stick the exp in
  438.     tstl    d7        | negative?
  439.     beq    addsf_ret_a
  440.     orl    #0x80000000,d0    | yup, negate it
  441.     bra    addsf_ret_a
  442. addsf_z:
  443.     clrl    d0
  444.     bra    addsf_ret_a
  445. addsf_ret_b:
  446.     movel    a6@(12),d0
  447. addsf_ret_a:
  448.     moveml    sp@+,#0x00FC    | snarf back all regs
  449.     unlk    a6
  450.     rts            | sigh
  451. # 
  452. # #ifdef L_negsf2
  453. # int
  454. # _negsf2 (a)
  455. #      union flt_or_int a;
  456. # {
  457. #   union flt_or_int intify;
  458. #   return INTIFY (-a.f);
  459. # }
  460. # #endif
  461.  
  462. .text
  463.     .even
  464. .globl __negsf2
  465. __negsf2:
  466.     movel    sp@(4),d0
  467.     beq    negsf2_z
  468.     eorl    #0x80000000,d0
  469. negsf2_z:
  470.     rts            | sigh
  471. # 
  472. # #ifdef L_subsf3
  473. # int
  474. # _subsf3 (a, b)
  475. #      union flt_or_int a, b;
  476. # {
  477. #   union flt_or_int intify;
  478. #   return INTIFY (a.f - b.f);
  479. # }
  480. # #endif
  481.  
  482. .text
  483.     .even
  484. .globl __subsf3
  485. __subsf3:
  486.     tstl    sp@(8)        | kludge.  just negate b and add
  487.     beq    subsf_bz    | zero.  don't bother
  488.     eorl    #0x80000000,sp@(8)    | negate it
  489.     jmp    __addsf3
  490. subsf_bz:
  491.     movel    sp@(4),d0
  492.     rts
  493.  
  494. # 
  495. # #ifdef L_cmpsf2
  496. # int
  497. # _cmpsf2 (a, b)
  498. #      union flt_or_int a, b;
  499. # {
  500. #   union flt_or_int intify;
  501. #   if (a.f > b.f)
  502. #     return 1;
  503. #   else if (a.f < b.f)
  504. #     return -1;
  505. #   return 0;
  506. # }
  507. # #endif
  508.  
  509. .text
  510.     .even
  511. .globl __cmpsf2
  512. __cmpsf2:
  513.     movel    sp@(4),d0
  514.     movel    sp@(12),d1    | get a hi
  515. |
  516. | crockery.  If both neg and not equal, this algorithm lose.  find a better one!
  517. |
  518.     bpl    cmpsf2_p
  519.     tstl    d0
  520.     bpl    cmpsf2_p
  521.     cmpl    d1,d0
  522.     bgt    cmpsf2_m
  523.     blt    cmpsf2_1
  524.     beq    cmpsf2_z
  525. cmpsf2_p:
  526.     cmpl    d1,d0
  527.     beq    cmpsf2_z
  528.     bgt    cmpsf2_1
  529. cmpsf2_m:
  530.     movel    #-1,d0
  531.     rts
  532. cmpsf2_z:
  533.     clrl    d0
  534.     rts
  535. cmpsf2_1:
  536.     movel    #1,d0
  537.     rts            | sigh
  538. # 
  539. # #ifdef L_mulsf3
  540. # int
  541. # _mulsf3 (a, b)
  542. #      union flt_or_int a, b;
  543. # {
  544. #   union flt_or_int intify;
  545. #   return INTIFY (a.f * b.f);
  546. # }
  547. # #endif
  548.  
  549. .text
  550.     .even
  551. .globl __mulsf3
  552. __mulsf3:
  553. |
  554. | multiply.  take the numbers apart.  shift each exponent down to
  555. | 16 bits.  unsigned multiply those.  shift that down to 24 bits.
  556. | exponent is Ea + Eb.
  557. |
  558.  
  559.     link    a6,#-8        | 64 bit accum for mult
  560.     moveml    #0x3F00,sp@-    | save all data registers
  561.     movel    a6@(8),d0    | get a
  562.     beq    mulsf3_z
  563.     movel    a6@(12),d1    | get b
  564.     beq    mulsf3_z
  565.     movel    #23,d6        | shift count
  566.     movel    d0,d2        | get the exponent
  567.     lsrl    d6,d2        | and shift right
  568.     andl    #0xFF,d2
  569.     subl    #126,d2        | offset the exponent
  570.     movel    d1,d3        | get the exponent for b
  571.     lsrl    d6,d3        | and shift right
  572.     andl    #0xFF,d2
  573.     subl    #126,d3        | off set this one too
  574.  
  575.     clrl    d7        | negative result flag
  576.     andl    #0x7FFFFF,d0    | mask a for mantissa
  577.     orl    #0x800000,d0    | and put in hidden bit
  578.     tstl    a6@(8)        | test the original value
  579.     bpl    mulsf3_1    | pos, ok
  580.     eorl    #1,d7        | remember negative
  581. mulsf3_1:
  582.     andl    #0x7FFFFF,d1    | mask b for mantissa
  583.     orl    #0x800000,d1    | ditto
  584.     tstl    a6@(12)        | test ...
  585.     bpl    mulsf3_2
  586.     eorl    #1,d7
  587. mulsf3_2:
  588. |    lsrl    #8,d1        | shift this one down
  589. |    lsrl    #8,d0        | this one too...
  590. |    mulu    d1,d0        | do the multiply
  591.  
  592. |    beq    mulsf3_ret    | zero? ok, just return
  593. |    lsrl    #8,d0        | shift right again
  594.  
  595. |
  596. | we have mantissas as follows:
  597. |
  598. |    |...ah...|...al...|    |...bh...|...bl...|
  599. |
  600. | product is composed as:
  601. |
  602. |            |....al * bl....|
  603. |        |....al * bh....|
  604. |        |....ah * bl....|
  605. |    |....ah * bh....|
  606. |
  607. | then take the 24 bit chunk that's 16 bits in.
  608.  
  609.     movel    d0,d4
  610.     andl    #0xFFFF,d4    | al
  611.     movel    d1,d5
  612.     andl    #0xFFFF,d5    | bl
  613.     mulu    d5,d4        | that's al * bl
  614.     movel    d4,a6@(-4)    | into the accum
  615.     clrl    a6@(-8)        | zap the top part
  616.  
  617.     movel    d0,d4
  618.     andl    #0xFFFF,d4    | al
  619.     movel    d1,d5
  620.     movel    #16,d6        | shift count
  621.     lsrl    d6,d5        | bh
  622.     mulu    d5,d4        | al * bh
  623.     addl    d4,a6@(-6)
  624.  
  625.     movel    d0,d4
  626.     lsrl    d6,d4        | ah
  627.     movel    d1,d5
  628.     andl    #0xFFFF,d5    | bl
  629.     mulu    d5,d4        | ah * bl
  630.     addl    d4,a6@(-6)
  631.  
  632.     movel    d0,d4
  633.     lsrl    d6,d4        | ah
  634.     movel    d1,d5
  635.     lsrl    d6,d5        | bh
  636.     mulu    d5,d4        | ah * bh
  637.     addl    d4,a6@(-8)
  638.  
  639.     movel    a6@(-6),d0    | get the relevant part
  640.     lsrl    #8,d0        | and shift it down
  641.  
  642. mulsf3_norm:
  643.     btst    #23,d0        | normalized?
  644.     bne    mulsf3_ok
  645.     lsll    #1,d0
  646.     subql    #1,d2
  647.     bra    mulsf3_norm
  648.  
  649. mulsf3_ok:
  650.     andl    #0x7FFFFF,d0    | zap hidden bit
  651.     addl    d3,d2        | add Eb to Ea
  652.     addl    #126,d2        | fix offset
  653.     andl    #0xFF,d2    | whack to 8 bits
  654.     movel    #23,d6        | shift count
  655.     lsll    d6,d2        | shift up to right place
  656.     orl    d2,d0        | shove it in
  657.     tstl    d7        | sign neg?
  658.     beq    mulsf3_ret
  659.     orl    #0x80000000,d0    | set sign bit
  660.     bra    mulsf3_ret
  661. mulsf3_z:
  662.     clrl    d0
  663. mulsf3_ret:
  664.     moveml    sp@+,#0x00FC    | snarf back all regs
  665.     unlk    a6
  666.     rts            | sigh
  667. # 
  668. # #ifdef L_divsf3
  669. # int
  670. # _divsf3 (a, b)
  671. #      union flt_or_int a, b;
  672. # {
  673. #   union flt_or_int intify;
  674. #   return INTIFY (a.f / b.f);
  675. # }
  676. # #endif
  677.  
  678. .text
  679.     .even
  680. .globl __divsf3
  681. __divsf3:
  682. |
  683. | divide.  sort of like mult, exc we do shifts and subtracts to
  684. | do the division of the mantissa.  resultant exponent is Ea - Eb.
  685. |
  686.  
  687.     link    a6,#0        | don't need any locals
  688.     moveml    #0x3F00,sp@-    | save all data registers
  689.     movel    a6@(8),d0    | get a
  690.     movel    a6@(12),d1    | get b
  691.     movel    #23,d6        | shift count
  692.     movel    d0,d2        | get the exponent
  693.     lsrl    d6,d2        | and shift right
  694.     andl    #0xFF,d2
  695.     subl    #127,d2        | offset the exponent
  696.     movel    d1,d3        | get the exponent for b
  697.     lsrl    d6,d3        | and shift right
  698.     andl    #0xFF,d3
  699.     subl    #127,d3        | off set this one too
  700.  
  701.     clrl    d7        | negative result flag
  702.     andl    #0x7FFFFF,d0    | mask a for mantissa
  703.     orl    #0x800000,d0    | and put in hidden bit
  704.     tstl    a6@(8)        | test the original value
  705.     bpl    divsf3_1    | pos, ok
  706.     eorl    #1,d7        | remember negative
  707. divsf3_1:
  708.     andl    #0x7FFFFF,d1    | mask b for mantissa
  709.     orl    #0x800000,d1    | ditto
  710.     tstl    a6@(12)        | test ...
  711.     bpl    divsf3_2
  712.     eorl    #1,d7
  713. divsf3_2:
  714. |
  715. | for now, kludge.  shift Ma left and Mb right, then do an unsigned divide
  716. | and shift the result left.  Blech
  717. |
  718.  
  719. |    lsrl    #8,d1        | shift this one down
  720. |    lsll    #7,d0        | this one up
  721. |    divu    d1,d0        | do the divide
  722. |    andl    #0xFFFF,d0    | and mask off cruft
  723.  
  724. |    beq    divsf3_ret    | zero? ok, just return
  725. |    lsll    #8,d0        | shift left again
  726.  
  727. | same sort of trick as long divide, exc it's easier here, cause
  728. | the numbers (mantissas) are already bit-aligned.
  729.  
  730.     clrl    d4        | accumulator
  731.     movel    #0x800000,d5    | bit
  732.     lsll    #7,d0        | buy a little extra accuracy...
  733.     lsll    #7,d1
  734. divsf3_2a:
  735.     cmpl    d1,d0        | compare dividend to divisor
  736.     bmi    divsf3_2b    | nope, no bit here
  737.     orl    d5,d4        | put in the bit
  738.     subl    d1,d0        | and subtract
  739. divsf3_2b:
  740.     lsrl    #1,d1        | slide divisor down
  741.     lsrl    #1,d5        | slide bit down
  742.     bne    divsf3_2a    | and go round again
  743.     movel    d4,d0        | leave the result here
  744.  
  745. divsf3_3:
  746.     btst    #23,d0        | right place yet?
  747.     bne    divsf3_4
  748.     lsll    #1,d0
  749.     subql    #1,d2
  750.     bra    divsf3_3
  751. divsf3_4:
  752.     andl    #0x7FFFFF,d0    | zap hidden bit
  753.     subl    d3,d2        | sub Eb from Ea
  754.     addl    #127,d2        | fix offset
  755.     andl    #0xFF,d2    | whack to 8 bits
  756.     lsll    d6,d2        | shift up to right place
  757.     orl    d2,d0        | shove it in
  758.     tstl    d7        | sign neg?
  759.     beq    divsf3_ret
  760.     orl    #0x80000000,d0    | set sign bit
  761. divsf3_ret:
  762.     moveml    sp@+,#0x00FC    | snarf back all regs
  763.     unlk    a6
  764.  
  765.     rts            | sigh
  766. # 
  767. # #ifdef L_truncdfsf2
  768. # int
  769. # _truncdfsf2 (a)
  770. #      double a;
  771. # {
  772. #   union flt_or_int intify;
  773. #   return INTIFY (a);
  774. # }
  775. # #endif
  776.  
  777. .text
  778.     .even
  779. .globl __truncdfsf2
  780. __truncdfsf2:
  781.     movel    sp@(4),d0
  782.     rts
  783.  
  784. # 
  785. # #ifdef L_extendsfdf2
  786. # double
  787. # _extendsfdf2 (a)
  788. #      union flt_or_int a;
  789. # {
  790. #   union flt_or_int intify;
  791. #   return a.f;
  792. # }
  793. # #endif
  794.  
  795. .text
  796.     .even
  797. .globl __extendsfdf2
  798. __extendsfdf2:
  799.     movel    sp@(4),d0
  800.     clrl    d1
  801.     rts            | sigh
  802.     .even
  803. .text
  804.